M

MLOG

தமிழ்

Socket.IO பயன்படுத்தி நிகழ்நேர தரவு ஓடையை ஆராயுங்கள், இதில் அமைப்பு, செயல்படுத்தல், அளவிடுதல் மற்றும் உலகளாவிய பயன்பாடுகளுக்கான சிறந்த நடைமுறைகள் அடங்கும்.

நிகழ்நேர தரவு ஓடை: ஒரு Socket.IO செயல்படுத்தல் வழிகாட்டி

இன்றைய வேகமான டிஜிட்டல் உலகில், உடனடி புதுப்பிப்புகள் மற்றும் தடையற்ற தகவல்தொடர்பு தேவைப்படும் பயன்பாடுகளுக்கு நிகழ்நேர தரவு ஓடை மிகவும் முக்கியமானது. நேரடி அரட்டை பயன்பாடுகள் முதல் நிகழ்நேர பகுப்பாய்வு டாஷ்போர்டுகள் வரை, தரவை உடனடியாக அனுப்பும் திறன் பயனர் அனுபவத்தை மேம்படுத்துகிறது மற்றும் போட்டித்தன்மையை வழங்குகிறது. Socket.IO, ஒரு பிரபலமான ஜாவாஸ்கிரிப்ட் நூலகம், வலை கிளையண்டுகள் மற்றும் சர்வர்களுக்கு இடையில் நிகழ்நேர இருவழி தகவல்தொடர்பு செயல்படுத்துவதை எளிதாக்குகிறது. இந்த விரிவான வழிகாட்டி, Socket.IO-ஐப் பயன்படுத்தி நிகழ்நேர தரவு ஓடையை அமைத்து செயல்படுத்துவதற்கான செயல்முறையை உங்களுக்கு விளக்கும், இதில் அத்தியாவசிய கருத்துக்கள், நடைமுறை எடுத்துக்காட்டுகள் மற்றும் உலகளாவிய பயன்பாடுகளுக்கான சிறந்த நடைமுறைகள் ஆகியவை அடங்கும்.

நிகழ்நேர தரவு ஓடை என்றால் என்ன?

நிகழ்நேர தரவு ஓடை என்பது ஒரு தரவு மூலத்திலிருந்து ஒரு இலக்குக்கு குறிப்பிடத்தக்க தாமதமின்றி, தொடர்ச்சியாகவும் உடனடியாகவும் தரவை அனுப்புவதாகும். பாரம்பரிய கோரிக்கை-பதில் மாதிரிகளைப் போலல்லாமல், கிளையண்டுகள் மீண்டும் மீண்டும் புதுப்பிப்புகளைக் கோர வேண்டியிருக்கும், நிகழ்நேர ஓடை சர்வர்கள் தரவு கிடைத்தவுடன் அதை கிளையண்டுகளுக்கு அனுப்ப அனுமதிக்கிறது. இந்த அணுகுமுறை வினாடிக்கு வினாடி தகவல் தேவைப்படும் பயன்பாடுகளுக்கு அவசியமானது, அவை:

நிகழ்நேர தரவு ஓடையின் நன்மைகள் பின்வருமாறு:

Socket.IO அறிமுகம்

Socket.IO என்பது ஒரு ஜாவாஸ்கிரிப்ட் நூலகம் ஆகும், இது வலை கிளையண்டுகள் மற்றும் சர்வர்களுக்கு இடையில் நிகழ்நேர, இருவழி மற்றும் நிகழ்வு அடிப்படையிலான தகவல்தொடர்பை செயல்படுத்துகிறது. இது WebSockets போன்ற அடிப்படை போக்குவரத்து நெறிமுறைகளின் சிக்கல்களை நீக்கி, நிகழ்நேர பயன்பாடுகளை உருவாக்குவதற்கு எளிமையான மற்றும் உள்ளுணர்வுடன் கூடிய API-ஐ வழங்குகிறது. Socket.IO கிளையண்டிற்கும் சர்வருக்கும் இடையில் ஒரு நிலையான இணைப்பை நிறுவி, இரு தரப்பினரும் நிகழ்நேரத்தில் தரவை அனுப்பவும் பெறவும் அனுமதிக்கிறது.

Socket.IO-இன் முக்கிய அம்சங்கள்:

ஒரு Socket.IO திட்டத்தை அமைத்தல்

Socket.IO-உடன் தொடங்குவதற்கு, உங்கள் கணினியில் Node.js மற்றும் npm (Node Package Manager) நிறுவப்பட்டிருக்க வேண்டும். ஒரு அடிப்படை Socket.IO திட்டத்தை அமைக்க இந்த வழிமுறைகளைப் பின்பற்றவும்:

1. ஒரு திட்டக் கோப்பகத்தை உருவாக்கவும்

உங்கள் திட்டத்திற்கு ஒரு புதிய கோப்பகத்தை உருவாக்கி அதற்குள் செல்லவும்:

mkdir socketio-example
cd socketio-example

2. ஒரு Node.js திட்டத்தை துவக்கவும்

npm-ஐப் பயன்படுத்தி ஒரு புதிய Node.js திட்டத்தை துவக்கவும்:

npm init -y

3. Socket.IO மற்றும் Express-ஐ நிறுவவும்

Socket.IO மற்றும் Express (ஒரு பிரபலமான Node.js வலை கட்டமைப்பு) ஆகியவற்றை சார்புகளாக நிறுவவும்:

npm install socket.io express

4. சர்வர்-பக்க குறியீட்டை உருவாக்கவும் (index.js)

`index.js` என்ற பெயரில் ஒரு கோப்பை உருவாக்கி, பின்வரும் குறியீட்டைச் சேர்க்கவும்:

const express = require('express');
const http = require('http');
const { Server } = require("socket.io");

const app = express();
const server = http.createServer(app);
const io = new Server(server);

const port = 3000;

app.get('/', (req, res) => {
 res.sendFile(__dirname + '/index.html');
});

io.on('connection', (socket) => {
 console.log('ஒரு பயனர் இணைந்தார்');

 socket.on('disconnect', () => {
 console.log('பயனர் இணைப்பைத் துண்டித்தார்');
 });

 socket.on('chat message', (msg) => {
 io.emit('chat message', msg); // இணைக்கப்பட்டுள்ள அனைத்து கிளையண்டுகளுக்கும் செய்தியை ஒளிபரப்பவும்
 console.log('செய்தி: ' + msg);
 });
});

server.listen(port, () => {
 console.log(`சர்வர் ${port} போர்ட்டில் இயங்குகிறது`);
});

இந்த குறியீடு ஒரு Express சர்வரை அமைத்து Socket.IO-ஐ ஒருங்கிணைக்கிறது. இது உள்வரும் இணைப்புகளைக் கேட்கிறது மற்றும் 'connection', 'disconnect', மற்றும் 'chat message' போன்ற நிகழ்வுகளைக் கையாளுகிறது.

5. கிளையண்ட்-பக்க குறியீட்டை உருவாக்கவும் (index.html)

அதே கோப்பகத்தில் `index.html` என்ற பெயரில் ஒரு கோப்பை உருவாக்கி, பின்வரும் குறியீட்டைச் சேர்க்கவும்:

<!DOCTYPE html>
<html>
<head>
 <title>Socket.IO Chat</title>
 <style>
 body { font: 13px Helvetica, Arial; }
 form { background: #000; padding: 3px; position: fixed; bottom: 0; width: 100%; }
 form input { border: 0; padding: 10px; width: 90%; margin-right: .5%; }
 form button { background: rgb(130, 224, 255); border: none; padding: 10px; }
 #messages { list-style-type: none; margin: 0; padding: 0; }
 #messages li { padding: 5px 10px; }
 #messages li:nth-child(odd) { background: #eee; }
 </style>
</head>
<body>
 <ul id="messages"></ul>
 <form action="">
 <input id="m" autocomplete="off" /><button>Send</button>
 </form>
 <script src="/socket.io/socket.io.js"></script>
 <script>
 var socket = io();
 var messages = document.getElementById('messages');
 var form = document.querySelector('form');
 var input = document.getElementById('m');

 form.addEventListener('submit', function(e) {
 e.preventDefault();
 if (input.value) {
 socket.emit('chat message', input.value);
 input.value = '';
 }
 });

 socket.on('chat message', function(msg) {
 var item = document.createElement('li');
 item.textContent = msg;
 messages.appendChild(item);
 window.scrollTo(0, document.body.scrollHeight);
 });
 </script>
</body>
</html>

இந்த HTML கோப்பு செய்திகளை அனுப்புவதற்கான ஒரு உள்ளீட்டு புலம் மற்றும் பெறப்பட்ட செய்திகளைக் காண்பிப்பதற்கான ஒரு பட்டியலுடன் ஒரு அடிப்படை அரட்டை இடைமுகத்தை அமைக்கிறது. இது Socket.IO கிளையண்ட் நூலகம் மற்றும் செய்தி அனுப்புதல் மற்றும் பெறுதலைக் கையாளும் ஜாவாஸ்கிரிப்ட் குறியீட்டையும் கொண்டுள்ளது.

6. பயன்பாட்டை இயக்கவும்

உங்கள் டெர்மினலில் பின்வரும் கட்டளையை இயக்குவதன் மூலம் Node.js சர்வரைத் தொடங்கவும்:

node index.js

உங்கள் வலை உலாவியைத் திறந்து `http://localhost:3000` முகவரிக்குச் செல்லவும். நீங்கள் அரட்டை இடைமுகத்தைக் காண்பீர்கள். பல பயனர்களை உருவகப்படுத்த பல உலாவி சாளரங்கள் அல்லது தாவல்களைத் திறக்கவும். ஒரு சாளரத்தில் ஒரு செய்தியைத் தட்டச்சு செய்து Enter அழுத்தவும்; திறந்திருக்கும் அனைத்து சாளரங்களிலும் நிகழ்நேரத்தில் செய்தி தோன்றுவதைக் காண்பீர்கள்.

Socket.IO-இன் முக்கிய கருத்துக்கள்

வலுவான மற்றும் அளவிடக்கூடிய நிகழ்நேர பயன்பாடுகளை உருவாக்க Socket.IO-இன் முக்கிய கருத்துக்களைப் புரிந்துகொள்வது அவசியம்.

1. இணைப்புகள்

ஒரு இணைப்பு ஒரு கிளையண்டிற்கும் சர்வருக்கும் இடையில் ஒரு நிலையான இணைப்பைக் குறிக்கிறது. ஒரு கிளையண்ட் Socket.IO-ஐப் பயன்படுத்தி சர்வருடன் இணைக்கும்போது, கிளையண்ட் மற்றும் சர்வர் இரண்டிலும் ஒரு தனித்துவமான சாக்கெட் பொருள் உருவாக்கப்படுகிறது. இந்த சாக்கெட் பொருள் ஒருவருக்கொருவர் தொடர்பு கொள்ளப் பயன்படுகிறது.

// சர்வர்-பக்கம்
io.on('connection', (socket) => {
 console.log('சாக்கெட் ஐடியுடன் ஒரு பயனர் இணைந்தார்: ' + socket.id);

 socket.on('disconnect', () => {
 console.log('பயனர் இணைப்பைத் துண்டித்தார்');
 });
});

// கிளையண்ட்-பக்கம்
var socket = io();

2. நிகழ்வுகள்

கிளையண்டுகள் மற்றும் சர்வருக்கு இடையில் தரவைப் பரிமாறிக்கொள்வதற்கான முதன்மை வழிமுறை நிகழ்வுகள் ஆகும். Socket.IO ஒரு நிகழ்வு அடிப்படையிலான API-ஐப் பயன்படுத்துகிறது, இது தனிப்பயன் நிகழ்வுகளை வரையறுக்கவும் அவற்றை குறிப்பிட்ட செயல்களுடன் இணைக்கவும் உங்களை அனுமதிக்கிறது. கிளையண்டுகள் சர்வருக்கு நிகழ்வுகளை அனுப்பலாம், மற்றும் சர்வர் கிளையண்டுகளுக்கு நிகழ்வுகளை அனுப்பலாம்.

// சர்வர்-பக்கம்
io.on('connection', (socket) => {
 socket.on('custom event', (data) => {
 console.log('பெறப்பட்ட தரவு:', data);
 socket.emit('response event', { message: 'தரவு பெறப்பட்டது' });
 });
});

// கிளையண்ட்-பக்கம்
socket.emit('custom event', { message: 'கிளையண்டிலிருந்து வணக்கம்' });

socket.on('response event', (data) => {
 console.log('பெறப்பட்ட பதில்:', data);
});

3. ஒளிபரப்புதல்

ஒளிபரப்புதல் என்பது ஒரே நேரத்தில் பல இணைக்கப்பட்ட கிளையண்டுகளுக்கு தரவை அனுப்ப உங்களை அனுமதிக்கிறது. Socket.IO வெவ்வேறு ஒளிபரப்பு விருப்பங்களை வழங்குகிறது, அதாவது இணைக்கப்பட்ட அனைத்து கிளையண்டுகளுக்கும் தரவை அனுப்புதல், ஒரு குறிப்பிட்ட அறையில் உள்ள கிளையண்டுகளுக்கு தரவை அனுப்புதல் அல்லது அனுப்புநரைத் தவிர மற்ற அனைத்து கிளையண்டுகளுக்கும் தரவை அனுப்புதல்.

// சர்வர்-பக்கம்
io.on('connection', (socket) => {
 socket.on('new message', (msg) => {
 // இணைக்கப்பட்ட அனைத்து கிளையண்டுகளுக்கும் ஒளிபரப்பவும்
 io.emit('new message', msg);

 // அனுப்புநரைத் தவிர மற்ற அனைத்து கிளையண்டுகளுக்கும் ஒளிபரப்பவும்
 socket.broadcast.emit('new message', msg);
 });
});

4. அறைகள்

அறைகள் என்பது கிளையண்டுகளை ஒன்றாகக் குழுவாக்கி, ஒரு குறிப்பிட்ட அறையில் உள்ள கிளையண்டுகளுக்கு மட்டுமே தரவை அனுப்புவதற்கான ஒரு வழியாகும். அரட்டை அறைகள் அல்லது ஆன்லைன் கேமிங் அமர்வுகள் போன்ற குறிப்பிட்ட பயனர் குழுக்களை இலக்கு வைக்க வேண்டிய சூழ்நிலைகளுக்கு இது பயனுள்ளதாக இருக்கும். கிளையண்டுகள் மாறும் வகையில் அறைகளில் சேரலாம் அல்லது வெளியேறலாம்.

// சர்வர்-பக்கம்
io.on('connection', (socket) => {
 socket.on('join room', (room) => {
 socket.join(room);
 console.log(`பயனர் ${socket.id} அறை ${room}-ல் சேர்ந்தார்`);

 // அறையில் உள்ள அனைத்து கிளையண்டுகளுக்கும் ஒரு செய்தியை அனுப்பவும்
 io.to(room).emit('new user joined', `பயனர் ${socket.id} அறையில் சேர்ந்தார்`);
 });

 socket.on('send message', (data) => {
 // அறையில் உள்ள அனைத்து கிளையண்டுகளுக்கும் செய்தியை அனுப்பவும்
 io.to(data.room).emit('new message', data.message);
 });

 socket.on('leave room', (room) => {
 socket.leave(room);
 console.log(`பயனர் ${socket.id} அறை ${room}-லிருந்து வெளியேறினார்`);
 });
});

// கிளையண்ட்-பக்கம்
socket.emit('join room', 'room1');
socket.emit('send message', { room: 'room1', message: 'room1-லிருந்து வணக்கம்' });

socket.on('new message', (message) => {
 console.log('பெறப்பட்ட செய்தி:', message);
});

5. பெயர்வெளிகள்

பெயர்வெளிகள் உங்கள் பயன்பாட்டு தர்க்கத்தை ஒரே பகிரப்பட்ட அடிப்படை இணைப்பில் பிரித்து, பல நோக்கங்களுக்காக ஒரே TCP இணைப்பை மல்டிபிளெக்ஸ் செய்ய உங்களை அனுமதிக்கின்றன. அவற்றை ஒரே இயற்பியல் சாக்கெட்டிற்குள் தனித்தனி மெய்நிகர் "சாக்கெட்டுகள்" என்று நினைத்துப் பாருங்கள். நீங்கள் ஒரு பெயர்வெளியை ஒரு அரட்டைப் பயன்பாட்டிற்கும் மற்றொன்றை ஒரு விளையாட்டுக்கும் பயன்படுத்தலாம். இது தகவல்தொடர்பு சேனல்களை ஒழுங்கமைக்கப்பட்டதாகவும் அளவிடக்கூடியதாகவும் வைத்திருக்க உதவுகிறது.

//சர்வர்-பக்கம்
const chatNsp = io.of('/chat');

chatNsp.on('connection', (socket) => {
 console.log('யாரோ அரட்டையில் இணைந்தார்கள்');
 // ... உங்கள் அரட்டை நிகழ்வுகள் ...
});

const gameNsp = io.of('/game');

gameNsp.on('connection', (socket) => {
 console.log('யாரோ விளையாட்டில் இணைந்தார்கள்');
 // ... உங்கள் விளையாட்டு நிகழ்வுகள் ...
});

//கிளையண்ட்-பக்கம்
const chatSocket = io('/chat');
const gameSocket = io('/game');

chatSocket.emit('chat message', 'அரட்டையிலிருந்து வணக்கம்!');
gameSocket.emit('game action', 'வீரர் நகர்ந்தார்!');

Socket.IO உடன் நிகழ்நேர அம்சங்களை செயல்படுத்துதல்

Socket.IO-ஐப் பயன்படுத்தி சில பொதுவான நிகழ்நேர அம்சங்களை எவ்வாறு செயல்படுத்துவது என்று ஆராய்வோம்.

1. ஒரு நிகழ்நேர அரட்டை பயன்பாட்டை உருவாக்குதல்

நாம் முன்பு உருவாக்கிய அடிப்படை அரட்டை பயன்பாடு நிகழ்நேர அரட்டையின் அடிப்படைக் கொள்கைகளை நிரூபிக்கிறது. அதை மேம்படுத்த, நீங்கள் போன்ற அம்சங்களைச் சேர்க்கலாம்:

தட்டச்சு குறிகாட்டிகளைச் சேர்ப்பதற்கான ஒரு எடுத்துக்காட்டு இங்கே:

// சர்வர்-பக்கம்
io.on('connection', (socket) => {
 socket.on('typing', (username) => {
 // அனுப்புநரைத் தவிர மற்ற அனைத்து கிளையண்டுகளுக்கும் ஒளிபரப்பவும்
 socket.broadcast.emit('typing', username);
 });

 socket.on('stop typing', (username) => {
 // அனுப்புநரைத் தவிர மற்ற அனைத்து கிளையண்டுகளுக்கும் ஒளிபரப்பவும்
 socket.broadcast.emit('stop typing', username);
 });
});

// கிளையண்ட்-பக்கம்
input.addEventListener('input', () => {
 socket.emit('typing', username);
});

input.addEventListener('blur', () => {
 socket.emit('stop typing', username);
});

socket.on('typing', (username) => {
 typingIndicator.textContent = `${username} தட்டச்சு செய்கிறார்...`;
});

socket.on('stop typing', () => {
 typingIndicator.textContent = '';
});

2. ஒரு நிகழ்நேர பகுப்பாய்வு டாஷ்போர்டை உருவாக்குதல்

நிகழ்நேர பகுப்பாய்வு டாஷ்போர்டுகள் புதுப்பித்த அளவீடுகள் மற்றும் போக்குகளைக் காண்பிக்கின்றன, இது வணிக செயல்திறன் குறித்த மதிப்புமிக்க நுண்ணறிவுகளை வழங்குகிறது. நீங்கள் Socket.IO-ஐப் பயன்படுத்தி ஒரு தரவு மூலத்திலிருந்து நிகழ்நேரத்தில் டாஷ்போர்டுக்கு தரவை அனுப்பலாம்.

இதோ ஒரு எளிமையான எடுத்துக்காட்டு:

// சர்வர்-பக்கம்
const data = {
 pageViews: 1234,
 usersOnline: 567,
 conversionRate: 0.05
};

setInterval(() => {
 data.pageViews += Math.floor(Math.random() * 10);
 data.usersOnline += Math.floor(Math.random() * 5);
 data.conversionRate = Math.random() * 0.1;

 io.emit('dashboard update', data);
}, 2000); // ஒவ்வொரு 2 வினாடிக்கும் தரவை அனுப்பவும்

// கிளையண்ட்-பக்கம்
socket.on('dashboard update', (data) => {
 document.getElementById('pageViews').textContent = data.pageViews;
 document.getElementById('usersOnline').textContent = data.usersOnline;
 document.getElementById('conversionRate').textContent = data.conversionRate.toFixed(2);
});

3. ஒரு கூட்டு திருத்தக் கருவியை உருவாக்குதல்

கூட்டு திருத்தக் கருவிகள் பல பயனர்களை ஒரே நேரத்தில் ஆவணங்கள் அல்லது குறியீட்டைத் திருத்த அனுமதிக்கின்றன. Socket.IO-ஐப் பயன்படுத்தி பயனர்களிடையே நிகழ்நேரத்தில் மாற்றங்களை ஒத்திசைக்கலாம்.

இதோ ஒரு அடிப்படை எடுத்துக்காட்டு:

// சர்வர்-பக்கம்
io.on('connection', (socket) => {
 socket.on('text change', (data) => {
 // ஒரே அறையில் உள்ள மற்ற அனைத்து கிளையண்டுகளுக்கும் மாற்றங்களை ஒளிபரப்பவும்
 socket.broadcast.to(data.room).emit('text change', data.text);
 });
});

// கிளையண்ட்-பக்கம்
textarea.addEventListener('input', () => {
 socket.emit('text change', { room: roomId, text: textarea.value });
});

socket.on('text change', (text) => {
 textarea.value = text;
});

Socket.IO பயன்பாடுகளை அளவிடுதல்

உங்கள் Socket.IO பயன்பாடு வளரும்போது, நீங்கள் அளவிடுதலைப் பற்றி சிந்திக்க வேண்டும். Socket.IO அளவிடக்கூடியதாக வடிவமைக்கப்பட்டுள்ளது, ஆனால் அதிக எண்ணிக்கையிலான ஒரே நேர இணைப்புகளைக் கையாள சில உத்திகளை நீங்கள் செயல்படுத்த வேண்டும்.

1. கிடைமட்ட அளவிடுதல்

கிடைமட்ட அளவிடுதல் என்பது உங்கள் பயன்பாட்டை பல சர்வர்களில் விநியோகிப்பதை உள்ளடக்குகிறது. கிடைக்கக்கூடிய சர்வர்களில் உள்வரும் இணைப்புகளை விநியோகிக்க ஒரு சுமை சமநிலையைப் பயன்படுத்துவதன் மூலம் இதை அடையலாம். இருப்பினும், Socket.IO உடன், கிளையண்டுகள் தங்கள் இணைப்பின் காலத்திற்கு தொடர்ந்து ஒரே சர்வருக்கு அனுப்பப்படுவதை நீங்கள் உறுதி செய்ய வேண்டும். ஏனென்றால், Socket.IO இணைப்பு நிலையை பராமரிக்க நினைவகத்தில் உள்ள தரவு கட்டமைப்புகளை நம்பியுள்ளது. ஒட்டும் அமர்வுகள்/அமர்வு இணக்கத்தைப் பயன்படுத்துவது பொதுவாக தேவைப்படுகிறது.

2. Redis Adapter

Socket.IO Redis adapter பல Socket.IO சர்வர்களுக்கு இடையில் நிகழ்வுகளைப் பகிர உங்களை அனுமதிக்கிறது. இது Redis, ஒரு நினைவக தரவு ஸ்டோர், அனைத்து இணைக்கப்பட்ட சர்வர்களிலும் நிகழ்வுகளை ஒளிபரப்பப் பயன்படுத்துகிறது. இது இணைப்பு நிலையை இழக்காமல் உங்கள் பயன்பாட்டை கிடைமட்டமாக அளவிட உதவுகிறது.

// சர்வர்-பக்கம்
const { createAdapter } = require('@socket.io/redis-adapter');
const { createClient } = require('redis');

const pubClient = createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();

Promise.all([pubClient.connect(), subClient.connect()]).then(() => {
 io.adapter(createAdapter(pubClient, subClient));
 io.listen(3000);
});

3. சுமை சமநிலை

பல Socket.IO சர்வர்களில் போக்குவரத்தை விநியோகிக்க ஒரு சுமை சமநிலை முக்கியமானது. பொதுவான சுமை சமநிலை தீர்வுகளில் Nginx, HAProxy, மற்றும் AWS Elastic Load Balancing அல்லது Google Cloud Load Balancing போன்ற கிளவுட் அடிப்படையிலான சுமை சமநிலைகள் அடங்கும். கிளையண்டுகள் தொடர்ந்து ஒரே சர்வருக்கு அனுப்பப்படுவதை உறுதிசெய்ய உங்கள் சுமை சமநிலையை ஒட்டும் அமர்வுகளைப் பயன்படுத்தும்படி உள்ளமைக்கவும்.

4. செங்குத்து அளவிடுதல்

செங்குத்து அளவிடுதல் என்பது ஒரு தனி சர்வரின் வளங்களை (CPU, நினைவகம்) அதிகரிப்பதை உள்ளடக்குகிறது. இது கிடைமட்ட அளவிடுதலை விட செயல்படுத்த எளிமையானது என்றாலும், இதற்கு வரம்புகள் உள்ளன. இறுதியில், நீங்கள் ஒரு தனி சர்வரின் வளங்களை அதிகரிக்க முடியாத ஒரு நிலையை அடைவீர்கள்.

5. குறியீட்டை மேம்படுத்துதல்

திறமையான குறியீட்டை எழுதுவது உங்கள் Socket.IO பயன்பாட்டின் செயல்திறனை கணிசமாக மேம்படுத்தும். தேவையற்ற கணக்கீடுகளைத் தவிர்க்கவும், தரவு பரிமாற்றத்தைக் குறைக்கவும், உங்கள் தரவுத்தள வினவல்களை மேம்படுத்தவும். செயல்திறன் இடையூறுகளை அடையாளம் காண சுயவிவரக் கருவிகள் உங்களுக்கு உதவும்.

Socket.IO செயல்படுத்தலுக்கான சிறந்த நடைமுறைகள்

உங்கள் Socket.IO திட்டத்தின் வெற்றியை உறுதிப்படுத்த, இந்த சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

1. உங்கள் இணைப்புகளைப் பாதுகாக்கவும்

கிளையண்டுகள் மற்றும் சர்வருக்கு இடையேயான தகவல்தொடர்பை குறியாக்கம் செய்ய பாதுகாப்பான WebSockets (WSS) ஐப் பயன்படுத்தவும். இது முக்கியமான தரவை ஒட்டுக் கேட்பது மற்றும் சேதப்படுத்துவதிலிருந்து பாதுகாக்கிறது. உங்கள் டொமைனுக்கு ஒரு SSL சான்றிதழைப் பெற்று, உங்கள் சர்வரை WSS ஐப் பயன்படுத்தும்படி உள்ளமைக்கவும்.

2. அங்கீகாரம் மற்றும் அதிகாரத்தை செயல்படுத்தவும்

பயனர்களின் அடையாளத்தைச் சரிபார்க்க அங்கீகாரத்தையும், வளங்களுக்கான அணுகலைக் கட்டுப்படுத்த அதிகாரத்தையும் செயல்படுத்தவும். இது அங்கீகரிக்கப்படாத அணுகலைத் தடுக்கிறது மற்றும் உங்கள் பயன்பாட்டை தீங்கிழைக்கும் தாக்குதல்களிலிருந்து பாதுகாக்கிறது. JWT (JSON Web Tokens) அல்லது OAuth போன்ற நிறுவப்பட்ட அங்கீகார வழிமுறைகளைப் பயன்படுத்தவும்.

3. பிழைகளை சுமூகமாகக் கையாளவும்

எதிர்பாராத பிழைகளை சுமூகமாகக் கையாளவும், பயன்பாட்டு செயலிழப்புகளைத் தடுக்கவும் சரியான பிழை கையாளுதலை செயல்படுத்தவும். பிழைத்திருத்தம் மற்றும் கண்காணிப்பு நோக்கங்களுக்காக பிழைகளைப் பதிவு செய்யவும். பயனர்களுக்கு தகவல் தரும் பிழை செய்திகளை வழங்கவும்.

4. இதயத்துடிப்பு பொறிமுறையைப் பயன்படுத்தவும்

Socket.IO ஒரு உள்ளமைக்கப்பட்ட இதயத்துடிப்பு பொறிமுறையைக் கொண்டுள்ளது, ஆனால் நீங்கள் அதை சரியான முறையில் உள்ளமைக்க வேண்டும். செயலிழந்த இணைப்புகளைக் கண்டறிந்து கையாள ஒரு நியாயமான பிங் இடைவெளி மற்றும் பிங் நேரத்தைக் அமைக்கவும். நினைவகக் கசிவுகளைத் தடுக்க துண்டிக்கப்பட்ட கிளையண்டுகளுடன் தொடர்புடைய வளங்களை சுத்தம் செய்யவும்.

5. செயல்திறனைக் கண்காணிக்கவும்

சாத்தியமான சிக்கல்களை அடையாளம் காணவும் செயல்திறனை மேம்படுத்தவும் உங்கள் Socket.IO பயன்பாட்டின் செயல்திறனைக் கண்காணிக்கவும். இணைப்பு எண்ணிக்கை, செய்தி தாமதம் மற்றும் CPU பயன்பாடு போன்ற அளவீடுகளைக் கண்காணிக்கவும். Prometheus, Grafana, அல்லது New Relic போன்ற கண்காணிப்புக் கருவிகளைப் பயன்படுத்தவும்.

6. பயனர் உள்ளீட்டைச் சுத்திகரிக்கவும்

குறுக்கு-தள ஸ்கிரிப்டிங் (XSS) தாக்குதல்கள் மற்றும் பிற பாதுகாப்பு பாதிப்புகளைத் தடுக்க பயனர் உள்ளீட்டை எப்போதும் சுத்திகரிக்கவும். உலாவியில் காண்பிக்கும் முன் பயனர் வழங்கிய தரவை குறியாக்கம் செய்யவும். தரவு எதிர்பார்க்கப்படும் வடிவங்களுக்கு இணங்குவதை உறுதிசெய்ய உள்ளீட்டு சரிபார்ப்பைப் பயன்படுத்தவும்.

7. விகித வரம்பு

உங்கள் பயன்பாட்டை துஷ்பிரயோகத்திலிருந்து பாதுகாக்க விகித வரம்பை செயல்படுத்தவும். ஒரு பயனர் ஒரு குறிப்பிட்ட காலத்திற்குள் செய்யக்கூடிய கோரிக்கைகளின் எண்ணிக்கையைக் கட்டுப்படுத்தவும். இது சேவை மறுப்பு (DoS) தாக்குதல்களைத் தடுக்கிறது மற்றும் உங்கள் சர்வர் வளங்களைப் பாதுகாக்கிறது.

8. சுருக்கம்

கிளையண்டுகள் மற்றும் சர்வருக்கு இடையில் அனுப்பப்படும் தரவின் அளவைக் குறைக்க சுருக்கத்தை இயக்கவும். இது செயல்திறனை கணிசமாக மேம்படுத்தும், குறிப்பாக அதிக அளவு தரவை அனுப்பும் பயன்பாடுகளுக்கு. Socket.IO `compression` மிடில்வேரைப் பயன்படுத்தி சுருக்கத்தை ஆதரிக்கிறது.

9. சரியான போக்குவரத்தைத் தேர்ந்தெடுக்கவும்

Socket.IO இயல்பாக WebSockets-க்கு மாறுகிறது, ஆனால் WebSockets கிடைக்கவில்லை என்றால் மற்ற முறைகளுக்கு (HTTP நீண்ட வாக்கெடுப்பு போன்றவை) பின்வாங்கும். Socket.IO இதை தானாகவே கையாளும் போது, அதன் தாக்கங்களைப் புரிந்து கொள்ளுங்கள். WebSockets பொதுவாக மிகவும் திறமையானவை. WebSockets பெரும்பாலும் தடுக்கப்படும் சூழல்களில் (சில கார்ப்பரேட் நெட்வொர்க்குகள், கட்டுப்படுத்தப்பட்ட ஃபயர்வால்கள்), நீங்கள் மாற்று உள்ளமைவுகள் அல்லது கட்டமைப்புகளைக் கருத்தில் கொள்ள வேண்டியிருக்கும்.

10. உலகளாவிய பரிசீலனைகள்: உள்ளூர்மயமாக்கல் மற்றும் நேர மண்டலங்கள்

உலகளாவிய பார்வையாளர்களுக்கான பயன்பாடுகளை உருவாக்கும்போது, உள்ளூர்மயமாக்கலில் கவனம் செலுத்துங்கள். பயனரின் இருப்பிடத்திற்கு ஏற்ப எண்கள், தேதிகள் மற்றும் நாணயங்களை வடிவமைக்கவும். நிகழ்வுகள் பயனரின் உள்ளூர் நேரத்தில் காட்டப்படுவதை உறுதிசெய்ய நேர மண்டலங்களைச் சரியாகக் கையாளவும். உங்கள் பயன்பாட்டை உள்ளூர்மயமாக்கும் செயல்முறையை எளிதாக்க சர்வதேசமயமாக்கல் (i18n) நூலகங்களைப் பயன்படுத்தவும்.

எடுத்துக்காட்டு: நேர மண்டலத்தைக் கையாளுதல்

உங்கள் சர்வர் நிகழ்வு நேரங்களை UTC-ல் சேமிக்கிறது என்று வைத்துக்கொள்வோம். பயனரின் உள்ளூர் நேர மண்டலத்தில் நிகழ்வு நேரத்தைக் காண்பிக்க `moment-timezone` போன்ற ஒரு நூலகத்தைப் பயன்படுத்தலாம்.

// சர்வர்-பக்கம் (நிகழ்வு நேரத்தை UTC-ல் அனுப்புதல்)
const moment = require('moment');

io.on('connection', (socket) => {
 socket.on('request event', () => {
 const eventTimeUTC = moment.utc(); // தற்போதைய நேரம் UTC-ல்
 socket.emit('event details', {
 timeUTC: eventTimeUTC.toISOString(),
 description: 'Global conference call'
 });
 });
});

// கிளையன்ட்-பக்கம் (பயனரின் உள்ளூர் நேரத்தில் காண்பித்தல்)
const moment = require('moment-timezone');

socket.on('event details', (data) => {
 const eventTimeLocal = moment.utc(data.timeUTC).tz(moment.tz.guess()); // பயனரின் நேர மண்டலத்திற்கு மாற்றவும்
 document.getElementById('eventTime').textContent = eventTimeLocal.format('MMMM Do YYYY, h:mm:ss a z');
});

எடுத்துக்காட்டு: நாணய வடிவமைத்தல்

நாணய மதிப்புகளைச் சரியாகக் காண்பிக்க, பயனரின் இருப்பிடத்திற்கு ஏற்ப நாணயத்தை வடிவமைக்க `Intl.NumberFormat` போன்ற ஒரு நூலகத்தைப் பயன்படுத்தவும்.

// கிளையண்ட்-பக்கம்
const priceUSD = 1234.56;
const userLocale = navigator.language || 'en-US'; // பயனரின் இருப்பிடத்தைக் கண்டறியவும்

const formatter = new Intl.NumberFormat(userLocale, {
 style: 'currency',
 currency: 'USD', // USD-ஐ ஒரு தொடக்கப் புள்ளியாகப் பயன்படுத்தவும், தேவைக்கேற்ப சரிசெய்யவும்
});

const formattedPrice = formatter.format(priceUSD);

document.getElementById('price').textContent = formattedPrice;

//வேறு நாணயத்தில் விலைகளைக் காட்ட:
const formatterEUR = new Intl.NumberFormat(userLocale, {
 style: 'currency',
 currency: 'EUR',
});

const priceEUR = 1100.00;
const formattedPriceEUR = formatterEUR.format(priceEUR);

document.getElementById('priceEUR').textContent = formattedPriceEUR;

முடிவுரை

Socket.IO வலைப் பயன்பாடுகளில் நிகழ்நேர தரவு ஓடையை செயல்படுத்துவதை எளிதாக்குகிறது. Socket.IO-இன் முக்கிய கருத்துக்களைப் புரிந்துகொண்டு, சிறந்த நடைமுறைகளைச் செயல்படுத்தி, உங்கள் பயன்பாட்டைப் பொருத்தமான முறையில் அளவிடுவதன் மூலம், இன்றைய டிஜிட்டல் உலகின் தேவைகளைப் பூர்த்தி செய்யும் வலுவான மற்றும் அளவிடக்கூடிய நிகழ்நேர பயன்பாடுகளை நீங்கள் உருவாக்கலாம். நீங்கள் ஒரு அரட்டை பயன்பாடு, ஒரு நிகழ்நேர பகுப்பாய்வு டாஷ்போர்டு அல்லது ஒரு கூட்டு திருத்தக் கருவியை உருவாக்கினாலும், Socket.IO உலகளாவிய பார்வையாளர்களுக்காக ஈர்க்கக்கூடிய மற்றும் பதிலளிக்கக்கூடிய பயனர் அனுபவங்களை உருவாக்கத் தேவையான கருவிகளையும் நெகிழ்வுத்தன்மையையும் வழங்குகிறது.

நிகழ்நேர தரவு ஓடை: ஒரு Socket.IO செயல்படுத்தல் வழிகாட்டி | MLOG